home *** CD-ROM | disk | FTP | other *** search
/ Programming Languages Suite / ProgramD2.iso / Borland / Borland C++ V5.02 / OCFINC.PAK / APPDESC.H next >
C/C++ Source or Header  |  1997-05-06  |  13KB  |  307 lines
  1. //----------------------------------------------------------------------------
  2. // ObjectComponents
  3. // Copyright (c) 1994, 1997 by Borland International, All Rights Reserved
  4. //
  5. // $Revision:   2.10  $
  6. //
  7. // TAppDescriptor - OLE application descriptor definitions
  8. //----------------------------------------------------------------------------
  9. #if !defined(OCF_APPDESC_H)
  10. #define OCF_APPDESC_H
  11.  
  12. #if !defined(OCF_AUTODEFS_H)
  13. # include <ocf/autodefs.h>
  14. #endif
  15.  
  16. #if defined(BI_NAMESPACE)
  17. namespace ClassLib {
  18. #endif
  19.  
  20. class _WSYSCLASS  TRegLink;
  21.  
  22. #if defined(BI_NAMESPACE)
  23. } // namespace ClassLib
  24. #endif
  25.  
  26. #if defined(BI_NAMESPACE)
  27. namespace OCF {
  28. #endif
  29.  
  30. //----------------------------------------------------------------------------
  31. // TAppDescriptor - application registration and browsing facilities
  32. //
  33.  
  34. class             TServedObjectCreator;
  35. class _ICLASS     TServedObject;
  36. class _ICLASS     TTypeLibrary;
  37. class _ICLASS     TCoClassInfo;
  38.  
  39. // Factory routine which creates OLE object
  40. //
  41. typedef IUnknown*
  42. (*TComponentFactory)(IUnknown* outer, uint32 options, uint32 id = 0);
  43.  
  44. //
  45. //
  46. class _ICLASS TAppDescriptor : public IClassFactory {
  47.   public:
  48.     TAppDescriptor(TRegList& regInfo, TComponentFactory callback,
  49.                    string& cmdLine, HINSTANCE hInst = _hInstance,
  50.                    const TRegLink* regLink = 0);
  51.    ~TAppDescriptor();
  52.  
  53.     operator          IUnknown*()            {return this;}
  54.     bool              IsAutomated() const    {return ClassCount > 0;}
  55.     TComponentFactory GetFactory() const     {return FactoryCallback;}
  56.     const TRegLink*   GetRegLinkHead() const {return LinkHead;}
  57.  
  58.     // Command line options accessors
  59.     //
  60.     void          ProcessCmdLine(string& cmdLine);
  61.     void          SetLangId(TLangId prevLang, const char* langIdStr);
  62.     bool          IsOptionSet(uint32 option) const  {return (Options & option) != 0;}
  63.     uint32        GetOptions() const                {return Options;}
  64.     void          SetOption(uint32 bit, bool state) {
  65.       if (state)
  66.         Options |= bit;
  67.       else
  68.         Options &= ~bit;
  69.     }
  70.  
  71.     // Registration management functions
  72.     //
  73.     void          RegisterClass();
  74.     void          UnregisterClass();
  75.     bool          RegisterObject(TObjectDescriptor app);
  76.     void          UnregisterObject();
  77.     TClassId      GetLinkGuid(int index);
  78.     void          RegisterServer(TLangId lang, const char* regFile = 0);
  79.     void          UnregisterServer(TLangId lang = 0, const char* = 0);
  80.     void          MakeTypeLib(TLangId lang, const char* = 0);
  81.  
  82.     // TAutoClass management functions
  83.     //
  84.     void          MergeAutoClasses();
  85.  
  86.     // TypeLibrary management functions
  87.     //
  88.     ITypeLib*     GetTypeLibrary();                  //NOTE: Caller MUST do a Release()
  89.     ITypeInfo*    CreateITypeInfo(TAutoClass& cls);  //NOTE: Caller MUST do a Release()
  90.     int           GetClassCount()      {return ClassCount;}
  91.     TLangId       GetAppLang()         {return AppLang;}
  92.     int           GetClassIndex(TAutoClass* cls);  // returns -1 if not found
  93.     bool          GetClassId(TAutoClass* cls, GUID& retId);
  94.     TAutoClass*   GetAutoClass(unsigned index);
  95.     TAutoClass*   GetAutoClass(const GUID& clsid);
  96.     TRegLink*     GetRegLink(const GUID& clsid);
  97.     uint16        GetVersionField(uint field);
  98.     const char*   GetAppName(TLangId lang) {return AppName->Translate(lang);}
  99.     const char*   GetAppDoc(TLangId lang)  {return AppDoc->Translate(lang);}
  100.     const char*   GetHelpFile(TLangId lang){return HelpFile->Translate(lang);}
  101.     void          WriteTypeLibrary(TLangId lang, const char* file);
  102.  
  103.     // TServedObject management functions
  104.     //
  105.     TUnknown*      CreateAutoApp(TObjectDescriptor app, uint32 options,
  106.                                  IUnknown* outer=0);
  107.     void           ReleaseAutoApp(TObjectDescriptor app);
  108.     TUnknown*      CreateAutoObject(TObjectDescriptor obj, TServedObject& app,
  109.                                     IUnknown* outer=0);
  110.     TUnknown*      CreateAutoObject(const void* obj, const typeinfo& objInfo,
  111.                                     const void* app, const typeinfo& appInfo,
  112.                                     IUnknown* outer=0);
  113.     TServedObject* FindServed(const void far* mostDerivedObj);
  114.     TServedObject* FindServed(TObjectDescriptor& objDesc);
  115.     void           AddServed(TServedObject& obj);
  116.     void           RemoveServed(TServedObject& obj);
  117.     void           InvalidateObject(const void* obj);
  118.     void           ReleaseObject(const void far* obj);
  119.     bool           IsBound() {return static_cast<bool>(ServedList != 0 || LockCount != 0);}
  120.     bool           IsActiveObject(TServedObject* obj) {return ActiveObject == obj;}
  121.     void           FlushServed();
  122.  
  123.     TBaseClassId  AppClassId;
  124.  
  125.   private:
  126.     void           Init(IMalloc* alloc = 0);  // called only from constructor
  127.     TServedObject* ServedList;     // List of outstanding IDispatch/ITypeInfo objs
  128.     TServedObject* ActiveObject;   // Currently registered active object
  129.     TServedObjectCreator* Creator; // Served Object creator class
  130.     TRegList&      RegInfo;        // Registration list for application
  131.     const char*    Version;        // Library version, stored as text string
  132.     TLocaleString* AppProgId;      // Progid of application
  133.     TLocaleString* AppName;        // Name of application, localizable
  134.     TLocaleString* AppDoc;         // Description of application, localizable
  135.     TLocaleString* HelpFile;       // Name of help file, localizable
  136.     TAutoClass::TAutoClassRef*
  137.                    ClassList;      // Array of automated class references
  138.     int            ClassCount;     // Count of classes, set when first scanned
  139.     int            DebugGuidOffset;// GUID offset for /Debug registration
  140.     int            LibGuidOffset;  // GUID offset for the app library
  141.     int            LinkGuidOffset; // GUID offset for the first doc template
  142.     int            LinkGuidCount;  // count of GUIDs assigned to doc templates
  143.     TLangId        AppLang;        // Language Id for this running instance
  144.     TTypeLibrary*  TypeLib;        // Type library, only while referenced
  145.     const TRegLink* LinkHead;      // Reglink list of reglists to register
  146.     TComponentFactory FactoryCallback;  // callback to create/destroy instance
  147.     HINSTANCE      AppInstance;
  148.     unsigned long  RefCnt;
  149.     unsigned       LockCount;
  150.     unsigned long  RegClassHdl;    // For unregistration
  151.     unsigned long  RegObjectHdl;   // For unregistration
  152.     uint32         Options;        // Command line option bit flags
  153.  
  154.     // For EXE or DLL component main, provide direct access for destructors
  155.     // For auxilliary DLLs, a table must be maintained of AppDesc vs. task Id
  156.     //
  157.     static TAppDescriptor* This;   // set by constructor to component instance
  158.  
  159.     // IUnknown interface
  160.     //
  161.     HRESULT       _IFUNC QueryInterface(const IID far& iid, void** retIface);
  162.     unsigned long _IFUNC AddRef();
  163.     unsigned long _IFUNC Release();
  164.  
  165.   public:
  166.  
  167.     // IClassFactory interface
  168.     //
  169.     HRESULT _IFUNC CreateInstance(IUnknown* outer, const IID FAR& iid, void** retObject);
  170.     HRESULT _IFUNC LockServer(int lock);
  171.  
  172.   friend class _ICLASS TTypeLibrary;
  173.   friend class _ICLASS TCoClassInfo;
  174.   friend TAppDescriptor* GetAppDescriptor();
  175. };
  176.  
  177. //
  178. // For EXE and DLL component main module, provide direct access to descriptor
  179. // For auxilliary DLLs, must use table of app descriptor vs. task Id
  180. //
  181. inline TAppDescriptor* GetAppDescriptor() {
  182.   return TAppDescriptor::This;
  183. }
  184.  
  185. class _ICLASS TTypeLibrary : public ITypeLib {
  186.   public:
  187.     TTypeLibrary(TAppDescriptor& appDesc, TLangId lang);
  188.    ~TTypeLibrary();
  189.  
  190.  
  191.     // Component typeinfo - NOTE: Caller MUST Release()
  192.     //
  193.     ITypeInfo*      CreateCoClassInfo();
  194.  
  195.   private:
  196.     TAppDescriptor& AppDesc;
  197.     unsigned long   RefCnt;
  198.     TLangId         Lang;
  199.     uint16          CoClassFlags;      // Type flags combined from autoclasses
  200.     int             CoClassImplCount;  // Number of interfaces in coclass
  201.  
  202.     // IUnknown interface
  203.     //
  204.     HRESULT       _IFUNC QueryInterface(const IID far& iid, void** retIface);
  205.     unsigned long _IFUNC AddRef();
  206.     unsigned long _IFUNC Release();
  207.  
  208.     // ITypeLib interface
  209.     //
  210.     unsigned int _IFUNC GetTypeInfoCount();
  211.     HRESULT      _IFUNC GetTypeInfo(unsigned index, ITypeInfo** retInfo);
  212.     HRESULT      _IFUNC GetTypeInfoType(unsigned index, TYPEKIND far* retKind);
  213.     HRESULT      _IFUNC GetTypeInfoOfGuid(const GUID& guid, ITypeInfo** retInfo);
  214.     HRESULT      _IFUNC GetLibAttr(TLIBATTR** retAttr);
  215.     HRESULT      _IFUNC GetTypeComp(ITypeComp** retComp);
  216.     HRESULT      _IFUNC GetDocumentation(int index, BSTR* retName,
  217.                                          BSTR* retDoc,
  218.                                          unsigned long* retHelpContext,
  219.                                          BSTR* retHelpFile);
  220.     HRESULT      _IFUNC IsName(OLECHAR* nameBuf, unsigned long hashVal,
  221.                                int* retFound);
  222.     HRESULT      _IFUNC FindName(OLECHAR* nameBuf, unsigned long lHashVal,
  223.                                  ITypeInfo** retInfo, MEMBERID* retId,
  224.                                  unsigned short far* inoutCount);
  225.     void         _IFUNC ReleaseTLibAttr(TLIBATTR* attr);
  226. };
  227.  
  228.  
  229. class _ICLASS TCoClassInfo : public ITypeInfo {
  230.   public:
  231.     TCoClassInfo(TAppDescriptor& appDesc, uint16 typeFlags, int implCount);
  232.    ~TCoClassInfo();
  233.  
  234.  
  235.   private:
  236.     TAppDescriptor& AppDesc;
  237.     unsigned long   RefCnt;
  238.     uint16          TypeFlags;   // type flags combined from autoclasses
  239.     int             ImplCount;   // number of interfaces in coclass
  240.     unsigned*       ImplList;    // array of indices to autoclasses
  241.     int             Default;     // interface marked as default
  242.     int             DefaultEvent;// event interface marked as default,source
  243.  
  244.     // IUnknown interface
  245.     //
  246.     HRESULT       _IFUNC QueryInterface(const IID far& iid, void** retIface);
  247.     unsigned long _IFUNC AddRef();
  248.     unsigned long _IFUNC Release();
  249.  
  250.     // ITypeInfo implementation
  251.     //
  252.     HRESULT _IFUNC GetTypeAttr(TYPEATTR** pptypeattr);
  253.     HRESULT _IFUNC GetTypeComp(ITypeComp** pptcomp);
  254.     HRESULT _IFUNC GetFuncDesc(unsigned int index, FUNCDESC** ppfuncdesc);
  255.     HRESULT _IFUNC GetVarDesc(unsigned int index, VARDESC far* far* ppvardesc);
  256.     HRESULT _IFUNC GetNames(MEMBERID memid, BSTR far* rgbstrNames,
  257.                             unsigned int cMaxNames,
  258.                             unsigned int far* pcNames);
  259.     HRESULT _IFUNC GetRefTypeOfImplType(unsigned int index, HREFTYPE far* phreftype);
  260.     HRESULT _IFUNC GetImplTypeFlags(unsigned int index, int far* pimpltypeflags);
  261.     HRESULT _IFUNC GetIDsOfNames(OLECHAR far* far* rgszNames,
  262.                                  unsigned int cNames,
  263.                                  MEMBERID far* rgmemid);
  264.     HRESULT _IFUNC Invoke(void far* pvInstance, MEMBERID memid,
  265.                           unsigned short wFlags,
  266.                           DISPPARAMS far *pdispparams,
  267.                           VARIANT far *pvarResult,
  268.                           EXCEPINFO far *pexcepinfo,
  269.                           unsigned int far *puArgErr);
  270.     HRESULT _IFUNC GetDocumentation(MEMBERID memid,
  271.                                     BSTR far* pbstrName,
  272.                                     BSTR far* pbstrDocString,
  273.                                     ulong far* pdwHelpContext,
  274.                                     BSTR far* pbstrHelpFile);
  275.     HRESULT _IFUNC GetDllEntry(MEMBERID memid, INVOKEKIND invkind,
  276.                                BSTR far* pbstrDllName,
  277.                                BSTR far* pbstrName,
  278.                                unsigned short far* pwOrdinal);
  279.     HRESULT _IFUNC GetRefTypeInfo(HREFTYPE hreftype,
  280.                                   ITypeInfo* far* pptinfo);
  281.     HRESULT _IFUNC AddressOfMember(MEMBERID memid, INVOKEKIND invkind,
  282.                                    void far* far* ppv);
  283.     HRESULT _IFUNC CreateInstance(IUnknown* punkOuter, const IID far& riid,
  284.                                   void far* far* ppvObj);
  285.     HRESULT _IFUNC GetMops(MEMBERID memid, BSTR far* pbstrMops);
  286.     HRESULT _IFUNC GetContainingTypeLib(ITypeLib* far* pptlib,
  287.                                         uint far* pindex);
  288.     void _IFUNC ReleaseTypeAttr(TYPEATTR far* ptypeattr);
  289.     void _IFUNC ReleaseFuncDesc(FUNCDESC far* pfuncdesc);
  290.     void _IFUNC ReleaseVarDesc(VARDESC far* pvardesc);
  291. };
  292.  
  293. //
  294. // external entry points for DLL servers
  295. //
  296. typedef HRESULT STDAPICALLTYPE (*TDllCanUnloadNow)();
  297. typedef HRESULT STDAPICALLTYPE (*TDllGetClassObject)(const GUID& clsid, const GUID& iid, void** retObj);
  298. typedef HRESULT STDAPICALLTYPE (*TDllRegisterServer)();
  299. typedef HRESULT STDAPICALLTYPE (*TDllUnregisterServer)();
  300. typedef HRESULT STDAPICALLTYPE (*TDllRegisterCommand)(const char* cmdLine);
  301.  
  302. #if defined(BI_NAMESPACE)
  303. } // namespace OCF
  304. #endif
  305.  
  306. #endif // OCF_APPDESC_H
  307.